#include "cfactory.h"  // 包含自定义头文件，可能包含一些函数声明或宏定义
#include "child.h"     // 包含子线程相关的头文件

struct sockaddr_in ser;  // 定义服务器地址结构体，用于存储服务器的IP和端口信息
Zhuce login_msg;         // 定义登录信息结构体，存储用户登录相关的信息（用户名、密码、token等）
char path[200] = {"/"};  // 定义当前路径，默认为根目录

// 打印当前用户和路径信息
void print(void)
{
    printf("[%s@Netdisk ~%s]$ ", login_msg.name, path);  // 打印用户名和当前路径
    fflush(stdout);  // 刷新输出缓冲区，确保立即显示
}

int main(int argc, char *argv[])
{
    ARGS_CHECK(argc, 3);  // 检查命令行参数数量是否正确（需要至少3个参数）

    int cFd, ret, type, epfd;  // 定义变量：客户端套接字文件描述符(cFd)、返回值(ret)、用户选择类型(type)、epoll实例(epfd)
    bzero(&ser, sizeof(ser));  // 清空服务器地址结构体
    ser.sin_family = AF_INET;  // 设置地址族为IPv4
    ser.sin_port = htons(atoi(argv[2]));  // 设置服务器端口号，从命令行参数获取并转换为网络字节序
    ser.sin_addr.s_addr = inet_addr(argv[1]);  // 设置服务器IP地址，从命令行参数获取并转换为网络字节序

    time_t now;  // 定义时间变量，用于记录当前时间
    struct epoll_event evs[10];  // 定义epoll事件数组，最多监听10个事件
    char buf[100], *passwd, *p, uppath[100];  // 定义缓冲区(buf)、密码指针(passwd)、字符串指针(p)、上传路径(uppath)
    QUR_msg qq_msg;  // 定义操作消息结构体，用于存储命令和参数
    File_info file_info;  // 定义文件信息结构体，用于存储文件名、大小等信息
    Train_t train;  // 定义数据传输结构体，用于封装通信数据
    int fds[2], vds[2];  // 定义两对本地套接字，分别用于普通线程和VIP线程
    process_data normal_child, vip_child;  // 定义普通线程和VIP线程的数据结构

    epfd = epoll_create(1);  // 创建epoll实例，用于监听多个文件描述符
    epoll_func(epfd, 0, EPOLL_CTL_ADD, EPOLLIN);  // 将标准输入添加到epoll监听

    socketpair(AF_LOCAL, SOCK_STREAM, 0, fds);  // 创建一对本地套接字，用于普通线程通信
    pthread_create(&normal_child.pid, NULL, normal_func, (void*)fds[1]);  // 创建普通线程，执行normal_func函数
    normal_child.fd = fds[0];  // 保存普通线程的套接字文件描述符
    epoll_func(epfd, normal_child.fd, EPOLL_CTL_ADD, EPOLLIN);  // 将普通线程的套接字添加到epoll监听

    socketpair(AF_LOCAL, SOCK_STREAM, 0, vds);  // 创建另一对本地套接字，用于VIP线程通信
    pthread_create(&vip_child.pid, NULL, vip_func, (void*)vds[1]);  // 创建VIP线程，执行vip_func函数
    vip_child.fd = vds[0];  // 保存VIP线程的套接字文件描述符

login_begin:  // 登录/注册入口标签
    system("clear");  // 清屏
    printf("请选择注册或者登陆：\n1:注册新账号\n2:已有账号直接登陆\n");  // 提示用户选择注册或登录
    scanf("%d", &type);  // 获取用户输入的选择类型
    if (type == 1)  // 如果用户选择注册
    {
        printf("请输入要注册的用户名\n");
        scanf("%s", login_msg.name);  // 获取用户名
        passwd = getpass("请输入密码：");  // 获取密码（隐藏输入）
        strcpy(buf, passwd);  // 将密码复制到缓冲区
        passwd = getpass("请再次输入密码确认：");  // 再次获取密码以确认
        if (strcmp(buf, passwd) != 0)  // 如果两次输入的密码不一致
        {
            printf("两次输入不一致，即将回到主界面\n");
            sleep(1);  // 等待1秒
            goto login_begin;  // 跳回登录/注册入口
        }
        else  // 如果密码一致
        {
            strcpy(train.buf, login_msg.name);  // 将用户名复制到数据传输结构体
            train.Len = strlen(train.buf) + 1;  // 计算用户名长度
            train.ctl_code = LOGIN_PRE;  // 设置控制码为注册请求
            cFd = socket(AF_INET, SOCK_STREAM, 0);  // 创建客户端套接字
            ERROR_CHECK(cFd, -1, "socket");  // 检查套接字创建是否成功
            ret = connect(cFd, (struct sockaddr*)&ser, sizeof(ser));  // 连接到服务器
            ERROR_CHECK(ret, -1, "connect");  // 检查连接是否成功
            ret = send(cFd, &train, train.Len + 8, 0);  // 发送注册请求
        }
    }
    else  // 如果用户选择登录
    {
        printf("请输入要登录的用户名\n");
        scanf("%s", login_msg.name);  // 获取用户名
        passwd = getpass("请输入密码：");  // 获取密码
        strcpy(buf, passwd);  // 将密码复制到缓冲区
        strcpy(train.buf, login_msg.name);  // 将用户名复制到数据传输结构体
        train.Len = strlen(train.buf) + 1;  // 计算用户名长度
        train.ctl_code = REGISTER_PRE;  // 设置控制码为登录请求
        cFd = socket(AF_INET, SOCK_STREAM, 0);  // 创建客户端套接字
        ERROR_CHECK(cFd, -1, "socket");  // 检查套接字创建是否成功
        ret = connect(cFd, (struct sockaddr*)&ser, sizeof(ser));  // 连接到服务器
        ERROR_CHECK(ret, -1, "connect");  // 检查连接是否成功
        ret = send(cFd, &train, train.Len + 8, 0);  // 发送登录请求
    }
    epoll_func(epfd, cFd, EPOLL_CTL_ADD, EPOLLIN);  // 将客户端套接字添加到epoll监听

    while (1)  // 主循环
    {
        int ready_num = epoll_wait(epfd, evs, 10, -1);  // 等待epoll事件
        for (int i = 0; i < ready_num; i++)  // 遍历所有就绪事件
        {
            if (evs[i].events == EPOLLIN && evs[i].data.fd == cFd)  // 如果是客户端套接字事件
            {
                ret = one_recv(cFd, &train);  // 接收服务器发送的数据
                if (ret == -1)  // 如果接收失败
                {
                    close(cFd);  // 关闭客户端套接字
                    epoll_func(epfd, cFd, EPOLL_CTL_DEL, EPOLLIN);  // 从epoll中移除
                    cFd = socket(AF_INET, SOCK_STREAM, 0);  // 重新创建客户端套接字
                    ret = connect(cFd, (struct sockaddr*)&ser, sizeof(ser));  // 重新连接服务器
                    ERROR_CHECK(ret, -1, "connect");  // 检查连接是否成功
                    epoll_func(epfd, cFd, EPOLL_CTL_ADD, EPOLLIN);  // 将新的客户端套接字添加到epoll监听
                    train.Len = sizeof(Zhuce);  // 设置数据长度
                    memcpy(train.buf, &login_msg, train.Len);  // 将登录信息复制到数据传输结构体
                    train.ctl_code = TOKEN_PLESE;  // 设置控制码为重连请求
                    ret = send(cFd, &train, train.Len + 8, 0);  // 发送重连请求
                    if (ret == -1)
                        exit(0);  // 如果发送失败，退出程序
                    continue;
                }
                switch (train.ctl_code)  // 根据控制码处理不同类型的响应
                {
                case LOGIN_NO:  // 注册失败
                    close(cFd);
                    epoll_func(epfd, cFd, EPOLL_CTL_DEL, EPOLLIN);
                    printf("账号已存在，请重新注册\n");
                    sleep(1);
                    goto login_begin;
                case LOGIN_POK:  // 注册成功
                    strcpy(login_msg.token, train.buf);  // 保存服务器返回的token
                    strcpy(login_msg.passward, crypt(buf, login_msg.token));  // 加密密码
                    train.Len = sizeof(Zhuce);
                    memcpy(train.buf, &login_msg, train.Len);
                    train.ctl_code = LOGIN_Q;
                    ret = send(cFd, &train, train.Len + 8, 0);
                    if (ret != -1)
                        printf("注册成功\n");
                    else
                        printf("网络繁忙，注册失败\n");
                    sleep(1);
                    close(cFd);
                    epoll_func(epfd, cFd, EPOLL_CTL_DEL, EPOLLIN);
                    goto login_begin;
                case REGISTER_NO:  // 登录失败
                    printf("账号/密码错误，请重新登录\n");
                    close(cFd);
                    epoll_func(epfd, cFd, EPOLL_CTL_DEL, EPOLLIN);
                    sleep(1);
                    goto login_begin;
                case REGISTER_POK:  // 登录成功
                    time(&now);
                    strcpy(login_msg.passward, crypt(buf, train.buf));
                    sprintf(login_msg.token, "%s %s", login_msg.name, ctime(&now));
                    login_msg.token[strlen(login_msg.token) - 1] = 0;
                    train.Len = sizeof(Zhuce);
                    memcpy(train.buf, &login_msg, train.Len);
                    train.ctl_code = REGISTER_Q;
                    ret = send(cFd, &train, train.Len + 8, 0);
                    break;
                case REGISTER_OK:  // 登录成功后的欢迎信息
                    system("clear");
                    printf("Hello: %s\n", login_msg.name);
                    printf("\n    登录成功\n\n");
                    printf("    'ps'----查看上传/下载进度\n\n    'rm'----删除文件或者文件夹（不能为空）\n");
                    printf("\n    'exit'----退出程序\n\n");
                    printf("    'mgets'----VIP多点下载\n\n");
                    strcpy(login_msg.passward, "0");
                    getchar();
                    print();
                    break;
                case LS_OK:  // 显示文件列表
                    printf("%s", train.buf);
                    printf("[%s@Netdisk ~%s]$ ", login_msg.name, path);
                    fflush(stdout);
                    break;
                case OPERATE_NO:  // 操作失败
                    printf("参数错误，操作失败\n");
                    print();
                    break;
                case OPERATE_OK:  // 操作成功
                    if (train.Len > 0)
                    {
                        memcpy(&qq_msg, train.buf, train.Len);
                        strcpy(login_msg.passward, qq_msg.buf);
                        strcpy(path, qq_msg.buf1);
                    }
                    print();
                    break;
                case DOWNLOAD_POK:  // 开始下载文件
                    memcpy(&file_info, train.buf, train.Len);
                    write(normal_child.fd, train.buf, train.Len);
                    printf("文件:%s 已经开始下载\n", file_info.filename);
                    print();
                    break;
                case UPLOAD_OK:  // 文件上传完成
                    memcpy(&file_info, train.buf, train.Len);
                    printf("file : %s 上传完成\n", file_info.filename);
                    print();
                    break;
                case UPLOAD_POK:  // 开始上传文件
                    memcpy(&file_info, train.buf, train.Len);
                    file_info.filesize = -1;
                    write(normal_child.fd, &file_info, train.Len);
                    write(normal_child.fd, uppath, 100);
                    int ccode = atoi(login_msg.passward);
                    write(normal_child.fd, &ccode, 4);
                    printf("文件:%s 已经开始上传\n", file_info.filename);
                    print();
                    break;
                case DOWN_MORE_POK:  // VIP多点下载
                    printf("shoudao train.len = %d\n", train.Len);
                    write(vip_child.fd, train.buf, train.Len);
                    break;
                }
            }
            if (evs[i].events == EPOLLIN && evs[i].data.fd == 0)  // 如果是标准输入事件
            {
                fgets(buf, 100, stdin);  // 获取用户输入
                buf[strlen(buf) - 1] = 0;  // 去掉末尾的换行符
                p = buf;
                while (*p != ' ' && *p != 0)
                    p++;  // 分割命令和参数
                if (*p != 0)
                    *(p++) = 0;
                if (strcmp(buf, "ls") == 0)  // 如果是ls命令
                {
                    train.Len = 0;
                    train.ctl_code = LS_Q;
                    ssend(cFd, epfd, &train);
                }
                else if (strcmp(buf, "cd") == 0 || strcmp(buf, "mkdir") == 0 || strcmp(buf, "rm") == 0)  // 如果是cd/mkdir/rm命令
                {
                    strcpy(qq_msg.buf, buf);
                    strcpy(qq_msg.buf1, p);
                    train.Len = sizeof(QUR_msg);
                    train.ctl_code = OPERATE_Q;
                    memcpy(train.buf, &qq_msg, train.Len);
                    ssend(cFd, epfd, &train);
                }
                else if (strcmp(buf, "gets") == 0)  // 如果是gets命令
                {
                    strcpy(train.buf, p);
                    train.Len = strlen(train.buf) + 1;
                    train.ctl_code = DOWNLOAD_PRE;
                    ssend(cFd, epfd, &train);
                }
                else if (strcmp(buf, "puts") == 0)  // 如果是puts命令
                {
                    if (p[strlen(p) - 1] == '/')
                    {
                        print();
                        break;
                    }
                    ret = get_file_info(p, &file_info);
                    if (ret == -1)
                        usleep(333333);
                    else
                    {
                        train.Len = sizeof(File_info);
                        train.ctl_code = UPLOAD_PRE;
                        memcpy(train.buf, &file_info, train.Len);
                        strcpy(uppath, p);
                        ssend(cFd, epfd, &train);
                    }
                }
                else if (strcmp(buf, "ps") == 0)  // 如果是ps命令
                {
                    file_info.filesize = -2;
                    write(normal_child.fd, &file_info, sizeof(File_info));
                }
                else if (strcmp(buf, "exit") == 0)  // 如果是exit命令
                {
                    exit(0);
                }
                else if (strcmp(buf, "mgets") == 0)  // 如果是mgets命令
                {
                    strcpy(train.buf, p);
                    train.Len = strlen(train.buf) + 1;
                    train.ctl_code = DOWN_MORE_PRE;
                    ssend(cFd, epfd, &train);
                }
                else
                {
                    printf("ERORR!\n");
                    print();
                }
            }
        }
    }
    return 0;
}













// #include "cfactory.h"
// #include "child.h"
// struct sockaddr_in ser;
// Zhuce login_msg;
// char path[200]={"/"};
// //Train_t train;
// //char code[50]={"0"};



// void print(void)
// {
// //    system("clear");
// //    printf("Hello %s\n",login_msg.name);
//     printf("[%s@Netdisk ~%s]$ ",login_msg.name,path);
//     fflush(stdout);
// }

// int main(int argc,char *argv[])
// {
//     ARGS_CHECK(argc,3);
//     int cFd,ret,type,epfd;
//     bzero(&ser,sizeof(ser));
//     ser.sin_family=AF_INET;
//     ser.sin_port=htons(atoi(argv[2]));
//     ser.sin_addr.s_addr=inet_addr(argv[1]);//点分十进制转为32位的网络字节序
//     time_t now;
//     struct epoll_event evs[10];
//     char buf[100],*passwd,*p,uppath[100];
//     QUR_msg qq_msg;
//     File_info file_info;
//     Train_t train;
//     int fds[2],vds[2];
//     process_data normal_child,vip_child;



//     epfd = epoll_create(1);
//     epoll_func(epfd,0,EPOLL_CTL_ADD,EPOLLIN);

//     socketpair(AF_LOCAL,SOCK_STREAM,0,fds);
//     pthread_create(&normal_child.pid,NULL,normal_func,(void*)fds[1]);
//     normal_child.fd = fds[0];
//     //normal_child.busy_num = 0;
//     epoll_func(epfd,normal_child.fd,EPOLL_CTL_ADD,EPOLLIN);


//     socketpair(AF_LOCAL,SOCK_STREAM,0,vds);
//     pthread_create(&vip_child.pid,NULL,vip_func,(void*)vds[1]);
//     vip_child.fd = vds[0];




// login_begin:
//     system("clear");
//     printf("请选择注册或者登陆：\n1:注册新账号\n2:已有账号直接登陆\n");
//     scanf("%d",&type);
//     if(type == 1)
//     {
//         printf("请输入要注册的用户名\n");
//         scanf("%s",login_msg.name);
//         passwd = getpass("请输入密码：");
//         strcpy(buf,passwd);
//         passwd = getpass("请再次输入密码确认：");
//         if(strcmp(buf,passwd)!=0)
//         {
//             printf("两次输入不一致，即将回到主界面\n");
//             sleep(1);
//             goto login_begin;
//         }else
//         {
//             strcpy(train.buf,login_msg.name);
//             train.Len = strlen(train.buf)+1;
//             train.ctl_code = LOGIN_PRE;
//             cFd=socket(AF_INET,SOCK_STREAM,0);
//             ERROR_CHECK(cFd,-1,"socket");
//             ret=connect(cFd,(struct sockaddr*)&ser,sizeof(ser));
//             ERROR_CHECK(ret,-1,"connect");
//      //       printf("connect successful\n");
//             ret = send(cFd,&train,train.Len+8,0);
//             // ssend(cFd,epfd);
//         }
//     }else
//     {
//         printf("请输入要登录的用户名\n");
//         scanf("%s",login_msg.name);
//         passwd = getpass("请输入密码：");
//         strcpy(buf,passwd);
//         strcpy(train.buf,login_msg.name);
//         train.Len = strlen(train.buf)+1;
//         train.ctl_code = REGISTER_PRE;
//         cFd=socket(AF_INET,SOCK_STREAM,0);
//         ERROR_CHECK(cFd,-1,"socket");
//         ret=connect(cFd,(struct sockaddr*)&ser,sizeof(ser));
//         ERROR_CHECK(ret,-1,"connect");
// //        printf("connect successful\n");
//         ret = send(cFd,&train,train.Len+8,0);
//         // ssend(cFd);
//     }
//     epoll_func(epfd,cFd,EPOLL_CTL_ADD,EPOLLIN);


//     while(1)
//     {
//         int ready_num = epoll_wait(epfd,evs,10,-1);
//         for(int i=0;i<ready_num;i++)
//         {
//            // if(evs[i].events==EPOLLIN && evs[i].data.fd == normal_child.fd)
//            // {
//            //     int z;
//            //     read(normal_child.fd,&z,4);
//            //     normal_child.busy_num--;
//           //  }
//             if(evs[i].events==EPOLLIN && evs[i].data.fd == cFd)
//             {
//                 ret = one_recv(cFd,&train);
//                 if(ret == -1)
//                 {
//                     close(cFd);
//                     epoll_func(epfd,cFd,EPOLL_CTL_DEL,EPOLLIN);
//                     cFd=socket(AF_INET,SOCK_STREAM,0);
//                     ret=connect(cFd,(struct sockaddr*)&ser,sizeof(ser));
//                     ERROR_CHECK(ret,-1,"connect");
//              //       printf("重连 successful\n");
//                     epoll_func(epfd,cFd,EPOLL_CTL_ADD,EPOLLIN);
//                     train.Len = sizeof(Zhuce);
//                     memcpy(train.buf,&login_msg,train.Len);
//                     train.ctl_code = TOKEN_PLESE;
//                     ret = send(cFd,&train,train.Len+8,0);
//                     if(ret ==-1)
//                         exit(0);
//                     //重连，发token;重连要在服务器更新当前code值
//                     //加入新的epoll
//                     //此次SEND发name,tolen,当前code值；
//                     continue;
//                 }
//                 switch(train.ctl_code)
//                 {
//                 case LOGIN_NO:
//                     close(cFd);
//                     epoll_func(epfd,cFd,EPOLL_CTL_DEL,EPOLLIN);
//                     printf("账号已存在，请重新注册\n");
//                     sleep(1);
//                     goto login_begin;
//                 case LOGIN_POK:
//                     strcpy(login_msg.token,train.buf);//此时token是颜值
//                     strcpy(login_msg.passward,crypt(buf,login_msg.token));
//                     //            printf("name = %s\nsalt = %s\npassward = %s\n",login_msg.name,
//                     //                  login_msg.token,login_msg.passward);
//                     train.Len = sizeof(Zhuce);
//                     memcpy(train.buf,&login_msg,train.Len);
//                     train.ctl_code = LOGIN_Q;
//                     ret = send(cFd,&train,train.Len+8,0);
//                     if(ret != -1)
//                         printf("注册成功\n");
//                     else
//                         printf("网络繁忙，注册失败\n");
//                     sleep(1);
//                     close(cFd);
//                     epoll_func(epfd,cFd,EPOLL_CTL_DEL,EPOLLIN);
//                     goto login_begin;
//                 case REGISTER_NO:
//                     printf("账号/密码错误，请重新登录\n");
//                     close(cFd);
//                     epoll_func(epfd,cFd,EPOLL_CTL_DEL,EPOLLIN);
//                     sleep(1);
//                     goto login_begin;
//                 case REGISTER_POK:
//                     time(&now);
//                     //           printf("salt = %s\n",train.buf);
//                     strcpy(login_msg.passward,crypt(buf,train.buf));
//                     sprintf(login_msg.token,"%s %s",login_msg.name,ctime(&now));
//                     login_msg.token[strlen(login_msg.token)-1]=0;
//                     //           printf("name = %s\ntoken = %s\npassward = %s\n",login_msg.name,
//                     //                 login_msg.token,login_msg.passward);
//                     train.Len = sizeof(Zhuce);
//                     memcpy(train.buf,&login_msg,train.Len);
//                     train.ctl_code = REGISTER_Q;
//                     ret = send(cFd,&train,train.Len+8,0);
//                     break;
//                 case REGISTER_OK:
//                     system("clear");
//                     printf("Hello: %s\n",login_msg.name);
//                     printf("\n    登录成功\n\n");
//                     printf("    'ps'----查看上传/下载进度\n\n    'rm'----删除文件或者文件夹（不能为空）\n");
//                     printf("\n    'exit'----退出程序\n\n");
//                     printf("    'mgets'----VIP多点下载\n\n");
//                     strcpy(login_msg.passward,"0");//code值为0；
//                     getchar();
//                   //  sleep(2);
//                     print();
//                     break;
//                 case LS_OK:
//                  //   print();
//                     printf("%s",train.buf);
//                     printf("[%s@Netdisk ~%s]$ ",login_msg.name,path);
//                     fflush(stdout);
//                     break;
//                 case OPERATE_NO:
//                     printf("参数错误，操作失败\n");
//                 //   usleep(666666);
//                     print();
//                     break;
//                 case OPERATE_OK:
//              //       printf("操作成功\n");
//                     if(train.Len >0)
//                     {
//                         memcpy(&qq_msg,train.buf,train.Len);
//                         //  strcpy(code,qq_msg.buf);
//                         strcpy(login_msg.passward,qq_msg.buf);
//                         strcpy(path,qq_msg.buf1);
//                     }
//               //      usleep(666666);
//                     print();
//                     break;
//                 case DOWNLOAD_POK:
//                     memcpy(&file_info,train.buf,train.Len);
//                 //    if(normal_child.busy_num >=10)
//                //     {
//                //         printf("已经达到下载数量上限，请稍后再试\n");
//                 //        break;
//                  //   }
//                     write(normal_child.fd,train.buf,train.Len);
//                     printf("文件:%s 已经开始下载\n",file_info.filename);
//                     print();
//               //      normal_child.busy_num++;
//                     break;
//                 case UPLOAD_OK:
//                     memcpy(&file_info,train.buf,train.Len);
//                     printf("file : %s 上传完成\n",file_info.filename);
//                     print();
//                     break;
//                 case UPLOAD_POK:
//                 //    if(normal_child.busy_num >=10)
//                //     {
//                //         printf("已经达到上传数量上限，请稍后再试\n");
//                 //        break;
//               //      }
//                //     normal_child.busy_num++;
//                     memcpy(&file_info,train.buf,train.Len);
//                     file_info.filesize = -1;//-1表示下载;
//                     write(normal_child.fd,&file_info,train.Len);
//                     write(normal_child.fd,uppath,100);
//                     int ccode = atoi(login_msg.passward);
//                     write(normal_child.fd,&ccode,4);
//                     printf("文件:%s 已经开始上传\n",file_info.filename);
//                     print();
//                     break;
//                 case DOWN_MORE_POK:
//                     printf("shoudao train.len = %d\n",train.Len);
//                     write(vip_child.fd,train.buf,train.Len);
//                     break;
//                 }
//             }
//             if(evs[i].events==EPOLLIN && evs[i].data.fd == 0)
//             {
//                 fgets(buf,100,stdin);
//                 buf[strlen(buf)-1]=0;
//                 p = buf;
//                 while(*p !=' '&& *p!=0)p++;
//                 if(*p!=0)
//                     *(p++)=0;
//                 if(strcmp(buf,"ls")==0)
//                 {
//                     train.Len =0;
//                     train.ctl_code =LS_Q;
//                     ssend(cFd,epfd,&train);
//                 }else
//                 if(strcmp(buf,"cd")==0||strcmp(buf,"mkdir")==0||strcmp(buf,"rm")==0)
//                 {
//                     strcpy(qq_msg.buf,buf);
//                     strcpy(qq_msg.buf1,p);
//                     train.Len = sizeof(QUR_msg);
//                     train.ctl_code = OPERATE_Q;
//                     memcpy(train.buf,&qq_msg,train.Len);
//                     ssend(cFd,epfd,&train);
//                 }else
//                 if(strcmp(buf,"gets")==0)
//                 {
//                     strcpy(train.buf,p);
//                     train.Len = strlen(train.buf)+1;
//                     train.ctl_code = DOWNLOAD_PRE;
//                     ssend(cFd,epfd,&train);
//                 }else
//                 if(strcmp(buf,"puts")==0)
//                 {
//                     if(p[strlen(p)-1]=='/')
//                     {
//                         print();
//                         break;
//                     }
//                    ret = get_file_info(p,&file_info);
//                    if(ret == -1)
//                        usleep(333333);
//                    else
//                    {
//                         train.Len = sizeof(File_info);
//                         train.ctl_code = UPLOAD_PRE;
//                         memcpy(train.buf,&file_info,train.Len);
//                         strcpy(uppath,p);
//                         ssend(cFd,epfd,&train);
//  //                       printf("send file suceful\n");
//                    }
//                 }else
//                 if(strcmp(buf,"ps")==0)
//                 {
//                     file_info.filesize =-2;
//                     write(normal_child.fd,&file_info,sizeof(File_info));
//                 }else
//                 if(strcmp(buf,"exit")==0)
//                 {
//                     exit(0);
//                 }else
//                 if(strcmp(buf,"mgets")==0)
//                 {
//                     strcpy(train.buf,p);
//                     train.Len = strlen(train.buf)+1;
//                     train.ctl_code = DOWN_MORE_PRE;
//                     ssend(cFd,epfd,&train);
//                 }else
//                 {
//                     printf("ERORR!\n");
//                     print();
//                 }
//             }
//         }
//     }
//     return 0;
// }
